/*
 * Copyright 2011 Katsunori Koyanagi
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package sweezy.swf.visitor
{
	import sweezy.swf.abc.Opcode;
	import sweezy.swf.abc.opcode.AbsJump;
	import sweezy.swf.abc.opcode.Add;
	import sweezy.swf.abc.opcode.AddD;
	import sweezy.swf.abc.opcode.AddI;
	import sweezy.swf.abc.opcode.AddP;
	import sweezy.swf.abc.opcode.Alloc;
	import sweezy.swf.abc.opcode.Applytype;
	import sweezy.swf.abc.opcode.Astype;
	import sweezy.swf.abc.opcode.Astypelate;
	import sweezy.swf.abc.opcode.Bitand;
	import sweezy.swf.abc.opcode.Bitnot;
	import sweezy.swf.abc.opcode.Bitor;
	import sweezy.swf.abc.opcode.Bitxor;
	import sweezy.swf.abc.opcode.Bkpt;
	import sweezy.swf.abc.opcode.Bkptline;
	import sweezy.swf.abc.opcode.Call;
	import sweezy.swf.abc.opcode.Callinterface;
	import sweezy.swf.abc.opcode.Callmethod;
	import sweezy.swf.abc.opcode.Callproperty;
	import sweezy.swf.abc.opcode.Callproplex;
	import sweezy.swf.abc.opcode.Callpropvoid;
	import sweezy.swf.abc.opcode.Callstatic;
	import sweezy.swf.abc.opcode.Callsuper;
	import sweezy.swf.abc.opcode.Callsuperid;
	import sweezy.swf.abc.opcode.Callsupervoid;
	import sweezy.swf.abc.opcode.Checkfilter;
	import sweezy.swf.abc.opcode.Codegenop;
	import sweezy.swf.abc.opcode.Coerce;
	import sweezy.swf.abc.opcode.CoerceA;
	import sweezy.swf.abc.opcode.CoerceB;
	import sweezy.swf.abc.opcode.CoerceD;
	import sweezy.swf.abc.opcode.CoerceI;
	import sweezy.swf.abc.opcode.CoerceO;
	import sweezy.swf.abc.opcode.CoerceS;
	import sweezy.swf.abc.opcode.CoerceU;
	import sweezy.swf.abc.opcode.Concat;
	import sweezy.swf.abc.opcode.Construct;
	import sweezy.swf.abc.opcode.Constructprop;
	import sweezy.swf.abc.opcode.Constructsuper;
	import sweezy.swf.abc.opcode.ConvertB;
	import sweezy.swf.abc.opcode.ConvertD;
	import sweezy.swf.abc.opcode.ConvertI;
	import sweezy.swf.abc.opcode.ConvertM;
	import sweezy.swf.abc.opcode.ConvertMP;
	import sweezy.swf.abc.opcode.ConvertO;
	import sweezy.swf.abc.opcode.ConvertS;
	import sweezy.swf.abc.opcode.ConvertU;
	import sweezy.swf.abc.opcode.Debug;
	import sweezy.swf.abc.opcode.Debugfile;
	import sweezy.swf.abc.opcode.Debugline;
	import sweezy.swf.abc.opcode.Declocal;
	import sweezy.swf.abc.opcode.DeclocalI;
	import sweezy.swf.abc.opcode.DeclocalP;
	import sweezy.swf.abc.opcode.Decode;
	import sweezy.swf.abc.opcode.Decrement;
	import sweezy.swf.abc.opcode.DecrementI;
	import sweezy.swf.abc.opcode.DecrementP;
	import sweezy.swf.abc.opcode.Deleteproperty;
	import sweezy.swf.abc.opcode.Divide;
	import sweezy.swf.abc.opcode.DivideP;
	import sweezy.swf.abc.opcode.Doubletoatom;
	import sweezy.swf.abc.opcode.Dup;
	import sweezy.swf.abc.opcode.Dxns;
	import sweezy.swf.abc.opcode.Dxnslate;
	import sweezy.swf.abc.opcode.Equals;
	import sweezy.swf.abc.opcode.EscXattr;
	import sweezy.swf.abc.opcode.EscXelem;
	import sweezy.swf.abc.opcode.Finddef;
	import sweezy.swf.abc.opcode.Findproperty;
	import sweezy.swf.abc.opcode.Findpropstrict;
	import sweezy.swf.abc.opcode.Getdescendants;
	import sweezy.swf.abc.opcode.Getglobalscope;
	import sweezy.swf.abc.opcode.Getglobalslot;
	import sweezy.swf.abc.opcode.Getlex;
	import sweezy.swf.abc.opcode.Getlocal;
	import sweezy.swf.abc.opcode.Getlocal0;
	import sweezy.swf.abc.opcode.Getlocal1;
	import sweezy.swf.abc.opcode.Getlocal2;
	import sweezy.swf.abc.opcode.Getlocal3;
	import sweezy.swf.abc.opcode.Getproperty;
	import sweezy.swf.abc.opcode.Getscopeobject;
	import sweezy.swf.abc.opcode.Getslot;
	import sweezy.swf.abc.opcode.Getsuper;
	import sweezy.swf.abc.opcode.Greaterequals;
	import sweezy.swf.abc.opcode.Greaterthan;
	import sweezy.swf.abc.opcode.Hasnext;
	import sweezy.swf.abc.opcode.Hasnext2;
	import sweezy.swf.abc.opcode.Ifeq;
	import sweezy.swf.abc.opcode.Iffalse;
	import sweezy.swf.abc.opcode.Ifge;
	import sweezy.swf.abc.opcode.Ifgt;
	import sweezy.swf.abc.opcode.Ifle;
	import sweezy.swf.abc.opcode.Iflt;
	import sweezy.swf.abc.opcode.Ifne;
	import sweezy.swf.abc.opcode.Ifnge;
	import sweezy.swf.abc.opcode.Ifngt;
	import sweezy.swf.abc.opcode.Ifnle;
	import sweezy.swf.abc.opcode.Ifnlt;
	import sweezy.swf.abc.opcode.Ifstricteq;
	import sweezy.swf.abc.opcode.Ifstrictne;
	import sweezy.swf.abc.opcode.Iftrue;
	import sweezy.swf.abc.opcode.In;
	import sweezy.swf.abc.opcode.Inclocal;
	import sweezy.swf.abc.opcode.InclocalI;
	import sweezy.swf.abc.opcode.InclocalP;
	import sweezy.swf.abc.opcode.Increment;
	import sweezy.swf.abc.opcode.IncrementI;
	import sweezy.swf.abc.opcode.IncrementP;
	import sweezy.swf.abc.opcode.Initproperty;
	import sweezy.swf.abc.opcode.Instanceof;
	import sweezy.swf.abc.opcode.Istype;
	import sweezy.swf.abc.opcode.Istypelate;
	import sweezy.swf.abc.opcode.Jump;
	import sweezy.swf.abc.opcode.Kill;
	import sweezy.swf.abc.opcode.Label;
	import sweezy.swf.abc.opcode.Lessequals;
	import sweezy.swf.abc.opcode.Lessthan;
	import sweezy.swf.abc.opcode.Lf32;
	import sweezy.swf.abc.opcode.Lf64;
	import sweezy.swf.abc.opcode.Li16;
	import sweezy.swf.abc.opcode.Li32;
	import sweezy.swf.abc.opcode.Li8;
	import sweezy.swf.abc.opcode.Lookupswitch;
	import sweezy.swf.abc.opcode.Lshift;
	import sweezy.swf.abc.opcode.Mark;
	import sweezy.swf.abc.opcode.Modulo;
	import sweezy.swf.abc.opcode.ModuloP;
	import sweezy.swf.abc.opcode.Multiply;
	import sweezy.swf.abc.opcode.MultiplyI;
	import sweezy.swf.abc.opcode.MultiplyP;
	import sweezy.swf.abc.opcode.Negate;
	import sweezy.swf.abc.opcode.NegateI;
	import sweezy.swf.abc.opcode.NegateP;
	import sweezy.swf.abc.opcode.Newactivation;
	import sweezy.swf.abc.opcode.Newarray;
	import sweezy.swf.abc.opcode.Newcatch;
	import sweezy.swf.abc.opcode.Newclass;
	import sweezy.swf.abc.opcode.Newfunction;
	import sweezy.swf.abc.opcode.Newobject;
	import sweezy.swf.abc.opcode.Nextname;
	import sweezy.swf.abc.opcode.Nextvalue;
	import sweezy.swf.abc.opcode.Nop;
	import sweezy.swf.abc.opcode.Not;
	import sweezy.swf.abc.opcode.Pop;
	import sweezy.swf.abc.opcode.Popscope;
	import sweezy.swf.abc.opcode.Prologue;
	import sweezy.swf.abc.opcode.Pushbyte;
	import sweezy.swf.abc.opcode.Pushdecimal;
	import sweezy.swf.abc.opcode.Pushdnan;
	import sweezy.swf.abc.opcode.Pushdouble;
	import sweezy.swf.abc.opcode.Pushfalse;
	import sweezy.swf.abc.opcode.Pushint;
	import sweezy.swf.abc.opcode.Pushnamespace;
	import sweezy.swf.abc.opcode.Pushnan;
	import sweezy.swf.abc.opcode.Pushnull;
	import sweezy.swf.abc.opcode.Pushscope;
	import sweezy.swf.abc.opcode.Pushshort;
	import sweezy.swf.abc.opcode.Pushstring;
	import sweezy.swf.abc.opcode.Pushtrue;
	import sweezy.swf.abc.opcode.Pushuint;
	import sweezy.swf.abc.opcode.Pushundefined;
	import sweezy.swf.abc.opcode.Pushwith;
	import sweezy.swf.abc.opcode.Returnvalue;
	import sweezy.swf.abc.opcode.Returnvoid;
	import sweezy.swf.abc.opcode.Rshift;
	import sweezy.swf.abc.opcode.Sendenter;
	import sweezy.swf.abc.opcode.Setglobalslot;
	import sweezy.swf.abc.opcode.Setlocal;
	import sweezy.swf.abc.opcode.Setlocal0;
	import sweezy.swf.abc.opcode.Setlocal1;
	import sweezy.swf.abc.opcode.Setlocal2;
	import sweezy.swf.abc.opcode.Setlocal3;
	import sweezy.swf.abc.opcode.Setproperty;
	import sweezy.swf.abc.opcode.Setslot;
	import sweezy.swf.abc.opcode.Setsuper;
	import sweezy.swf.abc.opcode.Sf32;
	import sweezy.swf.abc.opcode.Sf64;
	import sweezy.swf.abc.opcode.Si16;
	import sweezy.swf.abc.opcode.Si32;
	import sweezy.swf.abc.opcode.Si8;
	import sweezy.swf.abc.opcode.Strictequals;
	import sweezy.swf.abc.opcode.Subtract;
	import sweezy.swf.abc.opcode.SubtractI;
	import sweezy.swf.abc.opcode.SubtractP;
	import sweezy.swf.abc.opcode.Swap;
	import sweezy.swf.abc.opcode.Sweep;
	import sweezy.swf.abc.opcode.Sxi1;
	import sweezy.swf.abc.opcode.Sxi16;
	import sweezy.swf.abc.opcode.Sxi8;
	import sweezy.swf.abc.opcode.Throw;
	import sweezy.swf.abc.opcode.Timestamp;
	import sweezy.swf.abc.opcode.Typeof;
	import sweezy.swf.abc.opcode.UnknownOpecode;
	import sweezy.swf.abc.opcode.Urshift;
	import sweezy.swf.abc.opcode.Verifyop;
	import sweezy.swf.abc.opcode.Verifypass;
	import sweezy.swf.abc.opcode.Wb;
	import sweezy.swf.abc.ABC;
	import sweezy.swf.abc.structure.ClassInfo;
	import sweezy.swf.abc.structure.ClassTrait;
	import sweezy.swf.abc.structure.ConstTrait;
	import sweezy.swf.abc.structure.ConstantPoolInfo;
	import sweezy.swf.abc.structure.ExceptionInfo;
	import sweezy.swf.abc.structure.FunctionTrait;
	import sweezy.swf.abc.structure.GetterTrait;
	import sweezy.swf.abc.structure.InstanceInfo;
	import sweezy.swf.abc.structure.MetadataInfo;
	import sweezy.swf.abc.structure.MetadataItemInfo;
	import sweezy.swf.abc.structure.MethodBodyInfo;
	import sweezy.swf.abc.structure.MethodInfo;
	import sweezy.swf.abc.structure.MethodTrait;
	import sweezy.swf.abc.structure.MultinameInfo;
	import sweezy.swf.abc.structure.NamespaceInfo;
	import sweezy.swf.abc.structure.NamespaceSetInfo;
	import sweezy.swf.abc.structure.ScriptInfo;
	import sweezy.swf.abc.structure.SetterTrait;
	import sweezy.swf.abc.structure.SlotTrait;
	import sweezy.swf.abc.structure.TraitInfo;

	public class ABCWalker extends ABCVisitor
	{

		private var _abc:ABC;

		private var _cp:ConstantPoolInfo;

		public function ABCWalker()
		{
		}

		override public function visitABC(element:ABC):void
		{
			_abc = element;
			_cp = element.constantPool;
			element.constantPool.accept(this);

			for each (var methodInfo:MethodInfo in element.methodInfos)
			{
				methodInfo.accept(this);
			}
			for each (var metadataInfo:MetadataInfo in element.metadataInfos)
			{
				metadataInfo.accept(this);
			}
			for each (var instanceInfo:InstanceInfo in element.instanceInfos)
			{
				instanceInfo.accept(this);
			}
			for each (var classInfo:ClassInfo in element.classInfos)
			{
				classInfo.accept(this);
			}
			for each (var scriptInfo:ScriptInfo in element.scriptInfos)
			{
				scriptInfo.accept(this);
			}
			for each (var methodBodyInfo:MethodBodyInfo in element.methodBodyInfos)
			{
				methodBodyInfo.accept(this);
			}
		}

		override public function visitAbsJump(element:AbsJump):void
		{
			visitOpcode(element);
		}

		override public function visitAdd(element:Add):void
		{
			visitOpcode(element);
		}

		override public function visitAddD(element:AddD):void
		{
			visitOpcode(element);
		}

		override public function visitAddI(element:AddI):void
		{
			visitOpcode(element);
		}

		override public function visitAddP(element:AddP):void
		{
			visitOpcode(element);
		}

		override public function visitAlloc(element:Alloc):void
		{
			visitOpcode(element);
		}

		override public function visitApplytype(element:Applytype):void
		{
			visitOpcode(element);
		}

		override public function visitAstype(element:Astype):void
		{
			visitOpcode(element);
		}

		override public function visitAstypelate(element:Astypelate):void
		{
			visitOpcode(element);
		}

		override public function visitBitand(element:Bitand):void
		{
			visitOpcode(element);
		}

		override public function visitBitnot(element:Bitnot):void
		{
			visitOpcode(element);
		}

		override public function visitBitor(element:Bitor):void
		{
			visitOpcode(element);
		}

		override public function visitBitxor(element:Bitxor):void
		{
			visitOpcode(element);
		}

		override public function visitBkpt(element:Bkpt):void
		{
			visitOpcode(element);
		}

		override public function visitBkptline(element:Bkptline):void
		{
			visitOpcode(element);
		}

		override public function visitCall(element:Call):void
		{
			visitOpcode(element);
		}

		override public function visitCallinterface(element:Callinterface):void
		{
			visitOpcode(element);
		}

		override public function visitCallmethod(element:Callmethod):void
		{
			visitOpcode(element);
		}

		override public function visitCallproperty(element:Callproperty):void
		{
			visitOpcode(element);
		}

		override public function visitCallproplex(element:Callproplex):void
		{
			visitOpcode(element);
		}

		override public function visitCallpropvoid(element:Callpropvoid):void
		{
			visitOpcode(element);
		}

		override public function visitCallstatic(element:Callstatic):void
		{
			visitOpcode(element);
		}

		override public function visitCallsuper(element:Callsuper):void
		{
			visitOpcode(element);
		}

		override public function visitCallsuperid(element:Callsuperid):void
		{
			visitOpcode(element);
		}

		override public function visitCallsupervoid(element:Callsupervoid):void
		{
			visitOpcode(element);
		}

		override public function visitCheckfilter(element:Checkfilter):void
		{
			visitOpcode(element);
		}

		override public function visitClassInfo(element:ClassInfo):void
		{
			for each (var traitInfo:TraitInfo in element.traitInfos)
			{
				traitInfo.accept(this);
			}
		}

		override public function visitClassTrait(element:ClassTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitCodegenop(element:Codegenop):void
		{
			visitOpcode(element);
		}

		override public function visitCoerce(element:Coerce):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceA(element:CoerceA):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceB(element:CoerceB):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceD(element:CoerceD):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceI(element:CoerceI):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceO(element:CoerceO):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceS(element:CoerceS):void
		{
			visitOpcode(element);
		}

		override public function visitCoerceU(element:CoerceU):void
		{
			visitOpcode(element);
		}

		override public function visitConcat(element:Concat):void
		{
			visitOpcode(element);
		}

		override public function visitConstTrait(element:ConstTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitConstantPoolInfo(element:ConstantPoolInfo):void
		{
			for each (var namespaceInfo:NamespaceInfo in element.namespaceInfos)
			{
				if (namespaceInfo !== null)
				{
					namespaceInfo.accept(this);
				}
			}
			for each (var namespaceSetInfo:NamespaceSetInfo in element.namespaceSetInfos)
			{
				if (namespaceSetInfo !== null)
				{
					namespaceSetInfo.accept(this);
				}
			}
			for each (var multinameInfo:MultinameInfo in element.multinameInfos)
			{
				if (multinameInfo !== null)
				{
					multinameInfo.accept(this);
				}
			}
		}

		override public function visitConstruct(element:Construct):void
		{
			visitOpcode(element);
		}

		override public function visitConstructprop(element:Constructprop):void
		{
			visitOpcode(element);
		}

		override public function visitConstructsuper(element:Constructsuper):void
		{
			visitOpcode(element);
		}

		override public function visitConvertB(element:ConvertB):void
		{
			visitOpcode(element);
		}

		override public function visitConvertD(element:ConvertD):void
		{
			visitOpcode(element);
		}

		override public function visitConvertI(element:ConvertI):void
		{
			visitOpcode(element);
		}

		override public function visitConvertM(element:ConvertM):void
		{
			visitOpcode(element);
		}

		override public function visitConvertMP(element:ConvertMP):void
		{
			visitOpcode(element);
		}

		override public function visitConvertO(element:ConvertO):void
		{
			visitOpcode(element);
		}

		override public function visitConvertS(element:ConvertS):void
		{
			visitOpcode(element);
		}

		override public function visitConvertU(element:ConvertU):void
		{
			visitOpcode(element);
		}

		override public function visitDebug(element:Debug):void
		{
			visitOpcode(element);
		}

		override public function visitDebugfile(element:Debugfile):void
		{
			visitOpcode(element);
		}

		override public function visitDebugline(element:Debugline):void
		{
			visitOpcode(element);
		}

		override public function visitDeclocal(element:Declocal):void
		{
			visitOpcode(element);
		}

		override public function visitDeclocalI(element:DeclocalI):void
		{
			visitOpcode(element);
		}

		override public function visitDeclocalP(element:DeclocalP):void
		{
			visitOpcode(element);
		}

		override public function visitDecode(element:Decode):void
		{
			visitOpcode(element);
		}

		override public function visitDecrement(element:Decrement):void
		{
			visitOpcode(element);
		}

		override public function visitDecrementI(element:DecrementI):void
		{
			visitOpcode(element);
		}

		override public function visitDecrementP(element:DecrementP):void
		{
			visitOpcode(element);
		}

		override public function visitDeleteproperty(element:Deleteproperty):void
		{
			visitOpcode(element);
		}

		override public function visitDivide(element:Divide):void
		{
			visitOpcode(element);
		}

		override public function visitDivideP(element:DivideP):void
		{
			visitOpcode(element);
		}

		override public function visitDoubletoatom(element:Doubletoatom):void
		{
			visitOpcode(element);
		}

		override public function visitDup(element:Dup):void
		{
			visitOpcode(element);
		}

		override public function visitDxns(element:Dxns):void
		{
			visitOpcode(element);
		}

		override public function visitDxnslate(element:Dxnslate):void
		{
			visitOpcode(element);
		}

		override public function visitEquals(element:Equals):void
		{
			visitOpcode(element);
		}

		override public function visitEscXattr(element:EscXattr):void
		{
			visitOpcode(element);
		}

		override public function visitEscXelem(element:EscXelem):void
		{
			visitOpcode(element);
		}

		override public function visitFinddef(element:Finddef):void
		{
			visitOpcode(element);
		}

		override public function visitFindproperty(element:Findproperty):void
		{
			visitOpcode(element);
		}

		override public function visitFindpropstrict(element:Findpropstrict):void
		{
			visitOpcode(element);
		}

		override public function visitFunctionTrait(element:FunctionTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitGetdescendants(element:Getdescendants):void
		{
			visitOpcode(element);
		}

		override public function visitGetglobalscope(element:Getglobalscope):void
		{
			visitOpcode(element);
		}

		override public function visitGetglobalslot(element:Getglobalslot):void
		{
			visitOpcode(element);
		}

		override public function visitGetlex(element:Getlex):void
		{
			visitOpcode(element);
		}

		override public function visitGetlocal(element:Getlocal):void
		{
			visitOpcode(element);
		}

		override public function visitGetlocal0(element:Getlocal0):void
		{
			visitOpcode(element);
		}

		override public function visitGetlocal1(element:Getlocal1):void
		{
			visitOpcode(element);
		}

		override public function visitGetlocal2(element:Getlocal2):void
		{
			visitOpcode(element);
		}

		override public function visitGetlocal3(element:Getlocal3):void
		{
			visitOpcode(element);
		}

		override public function visitGetproperty(element:Getproperty):void
		{
			visitOpcode(element);
		}

		override public function visitGetscopeobject(element:Getscopeobject):void
		{
			visitOpcode(element);
		}

		override public function visitGetslot(element:Getslot):void
		{
			visitOpcode(element);
		}

		override public function visitGetsuper(element:Getsuper):void
		{
			visitOpcode(element);
		}

		override public function visitGetterTrait(element:GetterTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitGreaterequals(element:Greaterequals):void
		{
			visitOpcode(element);
		}

		override public function visitGreaterthan(element:Greaterthan):void
		{
			visitOpcode(element);
		}

		override public function visitHasnext(element:Hasnext):void
		{
			visitOpcode(element);
		}

		override public function visitHasnext2(element:Hasnext2):void
		{
			visitOpcode(element);
		}

		override public function visitIfeq(element:Ifeq):void
		{
			visitOpcode(element);
		}

		override public function visitIffalse(element:Iffalse):void
		{
			visitOpcode(element);
		}

		override public function visitIfge(element:Ifge):void
		{
			visitOpcode(element);
		}

		override public function visitIfgt(element:Ifgt):void
		{
			visitOpcode(element);
		}

		override public function visitIfle(element:Ifle):void
		{
			visitOpcode(element);
		}

		override public function visitIflt(element:Iflt):void
		{
			visitOpcode(element);
		}

		override public function visitIfne(element:Ifne):void
		{
			visitOpcode(element);
		}

		override public function visitIfnge(element:Ifnge):void
		{
			visitOpcode(element);
		}

		override public function visitIfngt(element:Ifngt):void
		{
			visitOpcode(element);
		}

		override public function visitIfnle(element:Ifnle):void
		{
			visitOpcode(element);
		}

		override public function visitIfnlt(element:Ifnlt):void
		{
			visitOpcode(element);
		}

		override public function visitIfstricteq(element:Ifstricteq):void
		{
			visitOpcode(element);
		}

		override public function visitIfstrictne(element:Ifstrictne):void
		{
			visitOpcode(element);
		}

		override public function visitIftrue(element:Iftrue):void
		{
			visitOpcode(element);
		}

		override public function visitIn(element:In):void
		{
			visitOpcode(element);
		}

		override public function visitInclocal(element:Inclocal):void
		{
			visitOpcode(element);
		}

		override public function visitInclocalI(element:InclocalI):void
		{
			visitOpcode(element);
		}

		override public function visitInclocalP(element:InclocalP):void
		{
			visitOpcode(element);
		}

		override public function visitIncrement(element:Increment):void
		{
			visitOpcode(element);
		}

		override public function visitIncrementI(element:IncrementI):void
		{
			visitOpcode(element);
		}

		override public function visitIncrementP(element:IncrementP):void
		{
			visitOpcode(element);
		}

		override public function visitInitproperty(element:Initproperty):void
		{
			visitOpcode(element);
		}

		override public function visitInstanceInfo(element:InstanceInfo):void
		{
			for each (var traitInfo:TraitInfo in element.traitInfos)
			{
				traitInfo.accept(this);
			}
		}

		override public function visitInstanceof(element:Instanceof):void
		{
			visitOpcode(element);
		}

		override public function visitIstype(element:Istype):void
		{
			visitOpcode(element);
		}

		override public function visitIstypelate(element:Istypelate):void
		{
			visitOpcode(element);
		}

		override public function visitJump(element:Jump):void
		{
			visitOpcode(element);
		}

		override public function visitKill(element:Kill):void
		{
			visitOpcode(element);
		}

		override public function visitLabel(element:Label):void
		{
			visitOpcode(element);
		}

		override public function visitLessequals(element:Lessequals):void
		{
			visitOpcode(element);
		}

		override public function visitLessthan(element:Lessthan):void
		{
			visitOpcode(element);
		}

		override public function visitLf32(element:Lf32):void
		{
			visitOpcode(element);
		}

		override public function visitLf64(element:Lf64):void
		{
			visitOpcode(element);
		}

		override public function visitLi16(element:Li16):void
		{
			visitOpcode(element);
		}

		override public function visitLi32(element:Li32):void
		{
			visitOpcode(element);
		}

		override public function visitLi8(element:Li8):void
		{
			visitOpcode(element);
		}

		override public function visitLookupswitch(element:Lookupswitch):void
		{
			visitOpcode(element);
		}

		override public function visitLshift(element:Lshift):void
		{
			visitOpcode(element);
		}

		override public function visitMark(element:Mark):void
		{
			visitOpcode(element);
		}

		override public function visitMetadataInfo(element:MetadataInfo):void
		{
			for each (var metadataItemInfo:MetadataItemInfo in element.items)
			{
				metadataItemInfo.accept(this);
			}
		}

		override public function visitMethodBodyInfo(element:MethodBodyInfo):void
		{
			for each (var opcode:Opcode in element.opcodes)
			{
				opcode.accept(this);
			}
			for each (var exceptionInfo:ExceptionInfo in element.exceptionInfos)
			{
				exceptionInfo.accept(this);
			}
			for each (var traitInfo:TraitInfo in element.traitInfos)
			{
				traitInfo.accept(this);
			}
		}

		override public function visitMethodTrait(element:MethodTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitModulo(element:Modulo):void
		{
			visitOpcode(element);
		}

		override public function visitModuloP(element:ModuloP):void
		{
			visitOpcode(element);
		}

		override public function visitMultiply(element:Multiply):void
		{
			visitOpcode(element);
		}

		override public function visitMultiplyI(element:MultiplyI):void
		{
			visitOpcode(element);
		}

		override public function visitMultiplyP(element:MultiplyP):void
		{
			visitOpcode(element);
		}

		override public function visitNegate(element:Negate):void
		{
			visitOpcode(element);
		}

		override public function visitNegateI(element:NegateI):void
		{
			visitOpcode(element);
		}

		override public function visitNegateP(element:NegateP):void
		{
			visitOpcode(element);
		}

		override public function visitNewactivation(element:Newactivation):void
		{
			visitOpcode(element);
		}

		override public function visitNewarray(element:Newarray):void
		{
			visitOpcode(element);
		}

		override public function visitNewcatch(element:Newcatch):void
		{
			visitOpcode(element);
		}

		override public function visitNewclass(element:Newclass):void
		{
			visitOpcode(element);
		}

		override public function visitNewfunction(element:Newfunction):void
		{
			visitOpcode(element);
		}

		override public function visitNewobject(element:Newobject):void
		{
			visitOpcode(element);
		}

		override public function visitNextname(element:Nextname):void
		{
			visitOpcode(element);
		}

		override public function visitNextvalue(element:Nextvalue):void
		{
			visitOpcode(element);
		}

		override public function visitNop(element:Nop):void
		{
			visitOpcode(element);
		}

		override public function visitNot(element:Not):void
		{
			visitOpcode(element);
		}

		public function visitOpcode(element:Opcode):void
		{
		}

		override public function visitPop(element:Pop):void
		{
			visitOpcode(element);
		}

		override public function visitPopscope(element:Popscope):void
		{
			visitOpcode(element);
		}

		override public function visitPrologue(element:Prologue):void
		{
			visitOpcode(element);
		}

		override public function visitPushbyte(element:Pushbyte):void
		{
			visitOpcode(element);
		}

		override public function visitPushdecimal(element:Pushdecimal):void
		{
			visitOpcode(element);
		}

		override public function visitPushdnan(element:Pushdnan):void
		{
			visitOpcode(element);
		}

		override public function visitPushdouble(element:Pushdouble):void
		{
			visitOpcode(element);
		}

		override public function visitPushfalse(element:Pushfalse):void
		{
			visitOpcode(element);
		}

		override public function visitPushint(element:Pushint):void
		{
			visitOpcode(element);
		}

		override public function visitPushnamespace(element:Pushnamespace):void
		{
			visitOpcode(element);
		}

		override public function visitPushnan(element:Pushnan):void
		{
			visitOpcode(element);
		}

		override public function visitPushnull(element:Pushnull):void
		{
			visitOpcode(element);
		}

		override public function visitPushscope(element:Pushscope):void
		{
			visitOpcode(element);
		}

		override public function visitPushshort(element:Pushshort):void
		{
			visitOpcode(element);
		}

		override public function visitPushstring(element:Pushstring):void
		{
			visitOpcode(element);
		}

		override public function visitPushtrue(element:Pushtrue):void
		{
			visitOpcode(element);
		}

		override public function visitPushuint(element:Pushuint):void
		{
			visitOpcode(element);
		}

		override public function visitPushundefined(element:Pushundefined):void
		{
			visitOpcode(element);
		}

		override public function visitPushwith(element:Pushwith):void
		{
			visitOpcode(element);
		}

		override public function visitReturnvalue(element:Returnvalue):void
		{
			visitOpcode(element);
		}

		override public function visitReturnvoid(element:Returnvoid):void
		{
			visitOpcode(element);
		}

		override public function visitRshift(element:Rshift):void
		{
			visitOpcode(element);
		}

		override public function visitScriptInfo(element:ScriptInfo):void
		{
			for each (var traitInfo:TraitInfo in element.traitInfos)
			{
				traitInfo.accept(this);
			}
		}

		override public function visitSendenter(element:Sendenter):void
		{
			visitOpcode(element);
		}

		override public function visitSetglobalslot(element:Setglobalslot):void
		{
			visitOpcode(element);
		}

		override public function visitSetlocal(element:Setlocal):void
		{
			visitOpcode(element);
		}

		override public function visitSetlocal0(element:Setlocal0):void
		{
			visitOpcode(element);
		}

		override public function visitSetlocal1(element:Setlocal1):void
		{
			visitOpcode(element);
		}

		override public function visitSetlocal2(element:Setlocal2):void
		{
			visitOpcode(element);
		}

		override public function visitSetlocal3(element:Setlocal3):void
		{
			visitOpcode(element);
		}

		override public function visitSetproperty(element:Setproperty):void
		{
			visitOpcode(element);
		}

		override public function visitSetslot(element:Setslot):void
		{
			visitOpcode(element);
		}

		override public function visitSetsuper(element:Setsuper):void
		{
			visitOpcode(element);
		}

		override public function visitSetterTrait(element:SetterTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitSf32(element:Sf32):void
		{
			visitOpcode(element);
		}

		override public function visitSf64(element:Sf64):void
		{
			visitOpcode(element);
		}

		override public function visitSi16(element:Si16):void
		{
			visitOpcode(element);
		}

		override public function visitSi32(element:Si32):void
		{
			visitOpcode(element);
		}

		override public function visitSi8(element:Si8):void
		{
			visitOpcode(element);
		}

		override public function visitSlotTrait(element:SlotTrait):void
		{
			visitTraitInfo(element);
		}

		override public function visitStrictequals(element:Strictequals):void
		{
			visitOpcode(element);
		}

		override public function visitSubtract(element:Subtract):void
		{
			visitOpcode(element);
		}

		override public function visitSubtractI(element:SubtractI):void
		{
			visitOpcode(element);
		}

		override public function visitSubtractP(element:SubtractP):void
		{
			visitOpcode(element);
		}

		override public function visitSwap(element:Swap):void
		{
			visitOpcode(element);
		}

		override public function visitSweep(element:Sweep):void
		{
			visitOpcode(element);
		}

		override public function visitSxi1(element:Sxi1):void
		{
			visitOpcode(element);
		}

		override public function visitSxi16(element:Sxi16):void
		{
			visitOpcode(element);
		}

		override public function visitSxi8(element:Sxi8):void
		{
			visitOpcode(element);
		}

		override public function visitThrow(element:Throw):void
		{
			visitOpcode(element);
		}

		override public function visitTimestamp(element:Timestamp):void
		{
			visitOpcode(element);
		}

		public function visitTraitInfo(element:TraitInfo):void
		{

		}

		override public function visitTypeof(element:Typeof):void
		{
			visitOpcode(element);
		}

		override public function visitUnknownOpecode(element:UnknownOpecode):void
		{
			visitOpcode(element);
		}

		override public function visitUrshift(element:Urshift):void
		{
			visitOpcode(element);
		}

		override public function visitVerifyop(element:Verifyop):void
		{
			visitOpcode(element);
		}

		override public function visitVerifypass(element:Verifypass):void
		{
			visitOpcode(element);
		}

		override public function visitWb(element:Wb):void
		{
			visitOpcode(element);
		}

		protected function get abc():ABC
		{
			return _abc;
		}

		protected function get constantPool():ConstantPoolInfo
		{
			return _cp;
		}
	}
}
